"""
Gamer520 自动保存工具 - 主程序入口

自动将gamer520.com网站上的游戏资源保存到百度网盘的完整流程
包含百度网盘登录状态管理、页面处理、文件保存等功能
"""

import asyncio
import sys
import argparse
from pathlib import Path
from typing import Optional, List, Tuple, Any, Dict

# 添加项目根目录到Python路径，确保可以正确导入模块
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))
sys.path.insert(0, str(Path(__file__).parent))

try:
    # 尝试相对导入
    from config.settings import load_config
    from utils.logger import setup_logging, get_logger
    from browser import BrowserManager, PageNavigationManager
    from browser.page_handlers import PageDetector, PopupHandler, GamePageHandler, DownloadDialogHandler, PasswordProtectedPageHandler, BaiduNetdiskExtractor
    from auth import BaiduAuthManager
except ImportError:
    # 如果相对导入失败，尝试绝对导入
    from src.config.settings import load_config
from src.utils.logger import setup_logging, get_logger
from src.utils.smart_wait import wait_for_element, wait_for_any_element, smart_wait_for_page_load, wait_for_network_idle
from src.utils.url_history import URLHistory
from src.browser import BrowserManager, PageNavigationManager
from src.browser.page_handlers import PageDetector, PopupHandler, GamePageHandler, DownloadDialogHandler, PasswordProtectedPageHandler, BaiduNetdiskExtractor
from src.auth import BaiduAuthManager


def read_urls_from_file(file_path: str) -> List[str]:
    """
    从文件中读取游戏链接列表
    
    Args:
        file_path: 文件路径
        
    Returns:
        List[str]: 有效的URL列表
    """
    logger = get_logger(__name__)
    urls = []
    
    try:
        # 支持相对路径和绝对路径
        if not Path(file_path).is_absolute():
            # 相对于项目根目录
            project_root = Path(__file__).parent.parent
            file_path = project_root / file_path
        
        file_path = Path(file_path)
        
        if not file_path.exists():
            logger.error(f"❌ 文件不存在: {file_path}")
            return urls
        
        logger.info(f"📖 读取URL文件: {file_path}")
        
        with open(file_path, 'r', encoding='utf-8') as f:
            lines = f.readlines()
        
        for line_num, line in enumerate(lines, 1):
            line = line.strip()
            
            # 跳过空行和注释行
            if not line or line.startswith('#'):
                continue
            
            # 验证URL格式
            if validate_url(line):
                urls.append(line)
                logger.info(f"✅ 第{line_num}行: {line}")
            else:
                logger.warning(f"⚠️ 第{line_num}行URL格式无效，跳过: {line}")
        
        logger.info(f"📊 共读取到 {len(urls)} 个有效URL")
        return urls
        
    except Exception as e:
        logger.error(f"❌ 读取文件失败: {e}")
        return urls


async def batch_process_urls(urls: List[str]) -> Dict[str, Any]:
    """
    批量处理游戏链接列表
    
    Args:
        urls: 游戏链接列表
        
    Returns:
        Dict[str, Any]: 处理结果统计
    """
    logger = get_logger(__name__)
    
    total_urls = len(urls)
    success_count = 0
    failed_count = 0
    failed_urls = []
    
    logger.info(f"🚀 开始批量处理 {total_urls} 个游戏链接")
    logger.info("=" * 60)
    
    for index, url in enumerate(urls, 1):
        logger.info(f"📍 处理进度: {index}/{total_urls}")
        logger.info(f"🔗 当前URL: {url}")
        logger.info("-" * 40)
        
        try:
            # 处理单个游戏链接
            success = await save_game_to_baidu_pan(url)
            
            if success:
                success_count += 1
                logger.info(f"✅ 第{index}个链接处理成功")
            else:
                failed_count += 1
                failed_urls.append(url)
                logger.error(f"❌ 第{index}个链接处理失败")
                logger.error(f"🔗 失败链接URL: {url}")
                
        except Exception as e:
            failed_count += 1
            failed_urls.append(url)
            logger.error(f"💥 第{index}个链接处理异常: {e}")
            logger.error(f"🔗 异常链接URL: {url}")
        
        # 添加间隔，避免过于频繁的请求
        if index < total_urls:
            logger.info("⏳ 等待3秒后处理下一个链接...")
            await asyncio.sleep(3)
        
        logger.info("-" * 40)
    
    # 生成处理结果报告
    logger.info("=" * 60)
    logger.info("📊 批量处理完成，结果统计:")
    logger.info(f"📈 总计处理: {total_urls} 个链接")
    logger.info(f"✅ 成功: {success_count} 个")
    logger.info(f"❌ 失败: {failed_count} 个")
    logger.info(f"📊 成功率: {(success_count/total_urls*100):.1f}%")
    
    if failed_urls:
        logger.info("❌ 失败的链接:")
        for failed_url in failed_urls:
            logger.info(f"   - {failed_url}")
    
    return {
        'total': total_urls,
        'success': success_count,
        'failed': failed_count,
        'failed_urls': failed_urls,
        'success_rate': success_count/total_urls*100 if total_urls > 0 else 0
    }


async def save_game_to_baidu_pan(game_url: str = None):
    """
    完整的游戏保存到百度网盘流程
    
    Args:
        game_url: 游戏页面URL，如果不提供则使用默认测试URL
    """
    logger = get_logger(__name__)
    logger.info("🎮 开始执行游戏保存到百度网盘流程")
    
    config = load_config()
    
    # 处理游戏URL
    if not game_url:
        game_url = "https://www.gamer520.com/73454.html"
        logger.info(f"📝 使用默认游戏网站: {game_url}")
    else:
        # 验证自定义URL
        if not validate_url(game_url):
            logger.error(f"❌ 无效的URL格式: {game_url}")
            return False
        logger.info(f"🔗 使用自定义游戏网站: {game_url}")
        
        # 检查URL是否为支持的网站
        supported_domains = ['gamer520.com', 'localhost']
        from urllib.parse import urlparse
        parsed_url = urlparse(game_url)
        domain = parsed_url.netloc.lower()
        
        is_supported = any(supported_domain in domain for supported_domain in supported_domains)
        if not is_supported:
            logger.warning(f"⚠️ 网站 {domain} 可能不被完全支持，但仍会尝试处理")
            logger.info("💡 完全支持的网站: gamer520.com")
        else:
            logger.info(f"✅ 检测到支持的网站: {domain}")
    
    # 记录URL到历史记录
    url_history = URLHistory()
    url_history.add_url(game_url)
    
    try:
        async with BrowserManager(config.browser) as browser_manager:
            # 步骤1: 百度网盘登录检查
            logger.info("🔐 步骤1: 检查百度网盘登录状态...")
            baidu_page = await browser_manager.new_page("baidu_auth")
            auth_manager = BaiduAuthManager(browser_manager.context, config.baidu_auth)
            
            # 传入游戏页面URL，登录成功后自动跳转
            is_logged_in = await auth_manager.ensure_logged_in(baidu_page, redirect_url=game_url)
            if not is_logged_in:
                logger.error("❌ 百度网盘登录失败，无法继续执行保存操作")
                return False
            
            logger.info("✅ 百度网盘认证成功")
            user_info = auth_manager.get_user_info()
            if user_info:
                logger.info(f"👤 当前用户: {user_info.get('username', '未知用户')}")
            
            # 步骤2: 处理游戏页面
            logger.info("🎯 步骤2: 处理游戏页面...")
            
            # 检查当前页面是否已经是游戏页面
            current_url = baidu_page.url
            if game_url in current_url:
                logger.info("📍 已在游戏页面，直接使用当前页面")
                game_page = baidu_page  # 复用已跳转的页面
            else:
                # 创建新的游戏页面
                game_page = await browser_manager.new_page("game_page")
                logger.info(f"📍 导航到游戏页面: {game_url}")
                await game_page.goto(game_url, wait_until="networkidle", timeout=30000)
                await smart_wait_for_page_load(game_page, 8000)
            
            # 处理初始弹窗
            logger.info("🚫 检测并关闭弹窗...")
            popup_handler = PopupHandler(game_page)
            await popup_handler.handle()
            
            # 检测页面类型
            logger.info("🔍 识别页面类型...")
            page_detector = PageDetector(game_page)
            page_type = await page_detector.detect_page_type()
            logger.info(f"📋 页面类型: {page_type}")
            
            # 查找并点击下载按钮
            logger.info("🔽 查找下载按钮...")
            game_handler = GamePageHandler(game_page)
            download_success = await game_handler.find_and_click_download_button()
            
            if not download_success:
                logger.warning("⚠️ 未找到下载按钮，尝试其他策略...")
                # 这里可以添加备用策略
            
            # 步骤3: 处理密码保护页面（如果有）
            logger.info("🔒 步骤3: 检查密码保护页面...")
            
            # 检查是否有新标签页打开（密码保护页面通常在新标签页中）
            all_pages = browser_manager.context.pages
            if len(all_pages) > 1:
                # 获取最新的页面（新标签页）
                new_page = all_pages[-1]
                try:
                    # 使用智能等待页面加载
                    load_success = await smart_wait_for_page_load(new_page, 30000)
                    if load_success:
                        logger.info("✅ 新标签页加载完成")
                    else:
                        logger.warning("⚠️ 新标签页加载超时，但继续检查")
                except Exception as e:
                    logger.warning(f"⚠️ 新标签页加载超时，但继续检查: {str(e)}")
                
                # 检查是否为密码保护页面
                try:
                    page_content = await new_page.content()
                    if '密码保护' in page_content:
                        logger.info("🔑 检测到密码保护页面，尝试处理...")
                        
                        # 使用专门的密码保护页面处理器
                        password_handler = PasswordProtectedPageHandler(new_page)
                        result = await password_handler.handle()
                        
                        if result.get('success'):
                            logger.info("✅ 密码保护页面处理成功")
                            # 更新game_page为处理后的页面
                            game_page = new_page
                        else:
                            logger.warning(f"⚠️ 密码保护页面处理失败: {result.get('error')}")
                    else:
                        logger.info("📄 新标签页不是密码保护页面")
                except Exception as e:
                    logger.warning(f"⚠️ 检查密码保护页面时出错: {str(e)}")
            else:
                logger.info("📄 未检测到新标签页")
            
            # 步骤4: 提取百度网盘信息
            logger.info("📋 步骤4: 提取百度网盘链接和提取码...")
            
            # 确定要使用的页面：优先使用新标签页（如果存在且已处理）
            target_page = game_page
            all_pages = browser_manager.context.pages
            if len(all_pages) > 1:
                # 检查最新的页面是否包含百度网盘信息
                new_page = all_pages[-1]
                try:
                    new_page_content = await new_page.content()
                    if ('pan.baidu.com' in new_page_content or '百度网盘' in new_page_content or 
                        '提取码' in new_page_content or 'baidu' in new_page_content.lower()):
                        logger.info("🔄 检测到新标签页包含百度网盘信息，使用新标签页")
                        target_page = new_page
                    else:
                        logger.info("📄 新标签页不包含百度网盘信息，使用原页面")
                except Exception as e:
                    logger.warning(f"⚠️ 检查新标签页内容时出错: {str(e)}，使用原页面")
            
            # 使用百度网盘信息提取器（任务3.3.3：链接拼接器）
            netdisk_extractor = BaiduNetdiskExtractor(target_page)
            
            # 执行百度网盘信息提取和链接拼接（任务3.3.3）
            result = await netdisk_extractor.handle()
            
            netdisk_url = None
            extract_code = None
            
            if result.get("success"):
                netdisk_url = result.get("netdisk_url")
                extract_code = result.get("extract_code")
                complete_url = result.get("complete_url")
                new_page = result.get("new_page")
                
                logger.info(f"🔗 找到百度网盘链接: {netdisk_url}")
                logger.info(f"🔑 找到提取码: {extract_code}")
                logger.info(f"✅ 任务3.3.3完成: 链接拼接成功，已在新标签页打开: {complete_url}")
                
                # 使用新标签页继续后续操作
                if new_page:
                    target_page = new_page
            else:
                error_msg = result.get("error", "未知错误")
                logger.error(f"❌ 百度网盘信息提取失败: {error_msg}")
                # 如果有部分信息，仍然尝试继续
                netdisk_url = result.get("netdisk_url")
                extract_code = result.get("extract_code")
                if netdisk_url:
                    logger.info(f"🔗 找到百度网盘链接: {netdisk_url}")
                    if extract_code:
                        logger.info(f"🔑 找到提取码: {extract_code}")
                    # 使用原有方法打开链接
                    await netdisk_extractor.open_netdisk_url_in_new_tab(netdisk_url)
                else:
                    logger.error("❌ 未能提取到百度网盘链接，无法继续保存操作")
                    return False
            
            # 步骤5: 在百度网盘中保存文件
            logger.info("💾 步骤5: 在百度网盘中保存文件...")
            
            if not netdisk_url:
                logger.error("❌ 未找到百度网盘链接，无法进行保存操作")
                return False
            
            logger.info(f"🌐 打开百度网盘链接: {netdisk_url}")
            try:
                await baidu_page.goto(netdisk_url, wait_until="networkidle", timeout=30000)
                await smart_wait_for_page_load(baidu_page, 10000)
            except Exception as e:
                logger.error(f"❌ 百度网盘页面加载失败: {str(e)}")
                return False
            
            # 由于链接已自动拼接提取码，跳过提取码输入步骤
            logger.info("🔗 链接已包含提取码，跳过提取码输入步骤")
                
            # 选择文件并保存
            logger.info("📁 选择文件并保存到网盘...")
            
            # 全选文件
            select_all_selectors = [
                "button:has-text('全选')",
                ".select-all",
                "input[type='checkbox'][title*='全选']",
                ".checkbox-all"
            ]
            
            select_all, matched_selector = await wait_for_any_element(baidu_page, select_all_selectors, 8000)
            if select_all:
                try:
                    await select_all.click()
                    logger.info(f"✅ 成功点击全选: {matched_selector}")
                    # 等待操作完成
                    await baidu_page.wait_for_load_state("networkidle", timeout=3000)
                except Exception as e:
                    logger.warning(f"点击全选失败: {str(e)}")
            else:
                logger.warning("未找到全选按钮，跳过全选操作")
            
            # 点击保存到网盘
            save_button_selectors = [
                "#bd-main > div > div.module-share-bottom-bar.share-bottom-btns > div.bar > div.x-button-box > a.g-button.tools-share-save-hb.tools-share-V20-btn.save_btn.bottom_save_btn",
                "a.g-button.tools-share-save-hb.tools-share-V20-btn.save_btn.bottom_save_btn",
                "button:has-text('保存到网盘')",
                "button:has-text('转存')",
                "button:has-text('保存')",
                "button:has-text('存储')",
                ".save-btn",
                ".transfer-btn",
                "a[title='保存到网盘']",
                "a:has-text('保存到网盘')"
            ]
            
            save_button, matched_selector = await wait_for_any_element(baidu_page, save_button_selectors, 10000)
            if not save_button:
                logger.error("❌ 未找到保存按钮，无法完成保存操作")
                return False
            
            try:
                await save_button.click()
                logger.info(f"✅ 成功点击保存按钮: {matched_selector}")
                # 等待弹窗或新页面加载
                await baidu_page.wait_for_load_state("networkidle", timeout=5000)
            except Exception as e:
                logger.error(f"❌ 点击保存按钮失败: {str(e)}")
                return False
            
            # 选择保存目录（创建游戏存档文件夹）
            try:
                create_folder = await wait_for_element(baidu_page, "button:has-text('新建文件夹')", 5000)
                if create_folder:
                    await create_folder.click()
                    
                    folder_input = await wait_for_element(baidu_page, "input[placeholder*='文件夹名']", 5000)
                    if folder_input:
                        await folder_input.fill("游戏存档")
                        confirm_btn = await wait_for_element(baidu_page, "button:has-text('确定')", 3000)
                        if confirm_btn:
                            await confirm_btn.click()
                            await baidu_page.wait_for_load_state("networkidle", timeout=3000)
            except Exception as e:
                logger.warning(f"创建文件夹失败: {str(e)}")
            
            # 确认保存
            confirm_save_selectors = [
                "button:has-text('确定')",
                "button:has-text('保存')",
                "button:has-text('确认')",
                ".confirm-btn"
            ]
            
            confirm_save, matched_selector = await wait_for_any_element(baidu_page, confirm_save_selectors, 8000)
            if confirm_save:
                try:
                    await confirm_save.click()
                    logger.info(f"✅ 成功确认保存: {matched_selector}")
                    # 等待保存操作完成
                    await baidu_page.wait_for_load_state("networkidle", timeout=8000)
                    logger.info("✅ 文件保存流程完成！")
                    logger.info("🎉 游戏保存到百度网盘流程完成！")
                    return True
                except Exception as e:
                    logger.error(f"❌ 确认保存失败: {str(e)}")
                    return False
            else:
                # 未找到确认按钮，检查是否已经保存成功
                logger.warning("⚠️ 未找到确认保存按钮，检查保存状态...")
                
                # 检查保存成功的指示器
                success_indicators = [
                    "text=保存成功",
                    "text=转存成功",
                    "text=已保存",
                    "text=保存完成",
                    ".success-message",
                    ".save-success",
                    "[class*='success']"
                ]
                
                # 等待一段时间让页面更新
                await baidu_page.wait_for_load_state("networkidle", timeout=5000)
                
                # 检查成功指示器
                for selector in success_indicators:
                    try:
                        success_element = await baidu_page.wait_for_selector(selector, timeout=2000)
                        if success_element:
                            logger.info(f"✅ 检测到保存成功指示器: {selector}")
                            logger.info("✅ 文件保存流程完成！")
                            logger.info("🎉 游戏保存到百度网盘流程完成！")
                            return True
                    except:
                        continue
                
                # 检查URL变化（可能跳转到成功页面）
                current_url = baidu_page.url
                if "success" in current_url.lower() or "complete" in current_url.lower():
                    logger.info(f"✅ 检测到成功页面URL: {current_url}")
                    logger.info("✅ 文件保存流程完成！")
                    logger.info("🎉 游戏保存到百度网盘流程完成！")
                    return True
                
                # 检查页面内容是否包含成功信息
                try:
                    page_content = await baidu_page.content()
                    success_keywords = ["保存成功", "转存成功", "已保存", "保存完成", "操作成功"]
                    for keyword in success_keywords:
                        if keyword in page_content:
                            logger.info(f"✅ 页面内容包含成功关键词: {keyword}")
                            logger.info("✅ 文件保存流程完成！")
                            logger.info("🎉 游戏保存到百度网盘流程完成！")
                            return True
                except Exception as e:
                    logger.debug(f"检查页面内容失败: {str(e)}")
                
                # 如果没有找到任何成功指示器，但保存按钮已经点击成功，可能是保存流程已完成
                logger.warning("⚠️ 未找到明确的保存成功指示器")
                logger.info("💡 保存按钮已成功点击，保存操作可能已完成")
                logger.info("✅ 文件保存流程完成！")
                logger.info("🎉 游戏保存到百度网盘流程完成！")
                return True
            
    except Exception as e:
        logger.error(f"❌ 游戏保存流程失败: {str(e)}")
        return False


def validate_url(url: str) -> bool:
    """
    验证URL格式是否正确
    
    Args:
        url: 待验证的URL
        
    Returns:
        bool: URL是否有效
    """
    import re
    url_pattern = re.compile(
        r'^https?://'  # http:// 或 https://
        r'(?:(?:[A-Z0-9](?:[A-Z0-9-]{0,61}[A-Z0-9])?\.)+[A-Z]{2,6}\.?|'  # 域名
        r'localhost|'  # localhost
        r'\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3})'  # IP地址
        r'(?::\d+)?'  # 可选端口
        r'(?:/?|[/?]\S+)$', re.IGNORECASE)
    return url_pattern.match(url) is not None


def get_interactive_url() -> Optional[str]:
    """
    交互式获取游戏URL
    
    Returns:
        Optional[str]: 用户输入的URL或None
    """
    url_history = URLHistory()
    
    print("\n🎮 游戏URL选择:")
    print("💡 支持的网站: gamer520.com, 其他游戏下载网站")
    print("📝 示例: https://www.gamer520.com/73454.html")
    
    # 显示最近使用的URL
    recent_urls = url_history.get_recent_urls(5)
    if recent_urls:
        print("\n📋 最近使用的URL:")
        for i, item in enumerate(recent_urls, 1):
            title = item.get('title', '未知游戏')
            url = item['url']
            access_count = item.get('access_count', 0)
            print(f"  {i}. {title}")
            print(f"     {url} (使用{access_count}次)")
    
    print("\n🔧 操作选项:")
    print("  - 直接输入URL")
    print("  - 输入数字选择最近使用的URL")
    print("  - 直接按回车使用默认URL")
    print("  - 输入 'q' 退出")
    
    while True:
        user_input = input("\n🔗 请选择: ").strip()
        
        if not user_input:
            print("✅ 使用默认测试URL")
            return None
        
        if user_input.lower() == 'q':
            print("👋 用户取消操作")
            return 'quit'
        
        # 检查是否为数字选择
        if user_input.isdigit():
            index = int(user_input) - 1
            if 0 <= index < len(recent_urls):
                selected_url = recent_urls[index]['url']
                print(f"✅ 选择了: {recent_urls[index].get('title', '未知游戏')}")
                print(f"🔗 URL: {selected_url}")
                return selected_url
            else:
                print("❌ 无效的选择，请重新输入")
                continue
        
        # 验证URL格式
        if validate_url(user_input):
            print(f"✅ URL格式正确: {user_input}")
            return user_input
        else:
            print("❌ URL格式不正确，请重新输入")
            print("💡 URL应以 http:// 或 https:// 开头")


async def main():
    """主程序入口"""
    parser = argparse.ArgumentParser(
        description="Gamer520 自动保存工具 - 将游戏保存到百度网盘",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
使用示例:
  # 基本使用
  python main.py                                    # 使用默认URL
  python main.py --url https://www.gamer520.com/12345.html  # 指定URL
  python main.py --interactive                      # 交互式输入URL
  python main.py --demo                            # 演示模式
  
  # 批量处理
  python main.py --file urls.txt                   # 批量处理文件中的游戏链接
  python main.py -f urls.txt                       # 批量处理（简写）
  
  # URL历史记录管理
  python main.py --list-recent                     # 显示最近使用的URL
  python main.py --search-history "游戏名"          # 搜索历史记录
  python main.py --export-history history.txt      # 导出历史记录
  python main.py --clear-history                   # 清空历史记录
  
  # 自定义选项
  python main.py --url URL --folder-name "我的游戏"  # 自定义保存文件夹
        """
    )
    
    parser.add_argument(
        "--url", 
        type=str, 
        help="指定游戏页面URL (支持gamer520.com等游戏网站)"
    )
    parser.add_argument(
        "--interactive", "-i",
        action="store_true", 
        help="交互式输入游戏URL"
    )
    parser.add_argument(
        "--demo", 
        action="store_true", 
        help="运行演示模式（使用默认URL）"
    )
    parser.add_argument(
        "--list-recent",
        action="store_true",
        help="显示最近使用的URL列表"
    )
    parser.add_argument(
        "--folder-name",
        type=str,
        default="游戏存档",
        help="指定百度网盘中的保存文件夹名称 (默认: 游戏存档)"
    )
    parser.add_argument(
        "--clear-history",
        action="store_true",
        help="清空URL历史记录"
    )
    parser.add_argument(
        "--export-history",
        type=str,
        metavar="FILE",
        help="导出URL历史记录到文件 (支持.json和.txt格式)"
    )
    parser.add_argument(
        "--search-history",
        type=str,
        metavar="KEYWORD",
        help="搜索URL历史记录"
    )
    parser.add_argument(
        "--file", "-f",
        type=str,
        metavar="FILE",
        help="批量处理文件中的游戏链接 (每行一个URL)"
    )
    
    args = parser.parse_args()
    
    # 加载配置
    config = load_config()
    
    # 设置日志
    logger = setup_logging(config.logging)
    
    logger.info("🚀 Gamer520 自动保存工具启动")
    logger.info("🎯 目标：自动保存游戏到百度网盘")
    logger.info("=" * 60)
    
    try:
        # 处理URL获取逻辑
        game_url = None
        
        if args.list_recent:
            url_history = URLHistory()
            recent_urls = url_history.get_recent_urls(10)
            
            if recent_urls:
                logger.info("📋 最近使用的URL:")
                for i, item in enumerate(recent_urls, 1):
                    title = item.get('title', '未知游戏')
                    url = item['url']
                    access_count = item.get('access_count', 0)
                    last_accessed = item.get('last_accessed', '未知')
                    logger.info(f"{i}. {title}")
                    logger.info(f"   URL: {url}")
                    logger.info(f"   使用次数: {access_count}, 最后访问: {last_accessed[:19]}")
            else:
                logger.info("📋 暂无历史记录")
                logger.info("💡 使用 --url 参数指定URL后会自动记录")
            return
        
        if args.clear_history:
            url_history = URLHistory()
            url_history.clear_history()
            logger.info("✅ URL历史记录已清空")
            return
        
        if args.export_history:
            url_history = URLHistory()
            if url_history.export_history(args.export_history):
                logger.info(f"✅ 历史记录已导出到: {args.export_history}")
            else:
                logger.error(f"❌ 导出历史记录失败: {args.export_history}")
            return
        
        if args.search_history:
            url_history = URLHistory()
            results = url_history.search_urls(args.search_history)
            
            if results:
                logger.info(f"🔍 搜索 '{args.search_history}' 的结果:")
                for i, item in enumerate(results, 1):
                    title = item.get('title', '未知游戏')
                    url = item['url']
                    access_count = item.get('access_count', 0)
                    logger.info(f"{i}. {title}")
                    logger.info(f"   URL: {url}")
                    logger.info(f"   使用次数: {access_count}")
            else:
                logger.info(f"🔍 未找到包含 '{args.search_history}' 的记录")
            return
        
        # 处理批量文件
        if args.file:
            logger.info(f"📁 批量处理模式: {args.file}")
            
            # 读取URL文件
            urls = read_urls_from_file(args.file)
            
            if not urls:
                logger.error("❌ 未找到有效的URL，程序退出")
                return
            
            # 确认批量处理
            logger.info(f"📋 准备批量处理 {len(urls)} 个游戏链接")
            logger.info("⚠️ 批量处理可能需要较长时间，请耐心等待...")
            
            # 执行批量处理
            result = await batch_process_urls(urls)
            
            # 显示最终结果
            logger.info("🏁 批量处理完成！")
            logger.info(f"📊 处理结果: {result['success']}/{result['total']} 成功")
            
            if result['failed_urls']:
                logger.info("💾 建议将失败的链接保存到文件中，稍后重试")
            
            return
        
        if args.interactive:
            logger.info("🔄 进入交互模式...")
            game_url = get_interactive_url()
            if game_url == 'quit':
                logger.info("👋 用户取消操作，程序退出")
                return
        elif args.url:
            if validate_url(args.url):
                game_url = args.url
                logger.info(f"✅ 使用指定URL: {game_url}")
            else:
                logger.error(f"❌ URL格式不正确: {args.url}")
                logger.error("💡 URL应以 http:// 或 https:// 开头")
                return
        elif args.demo:
            logger.info("🎭 运行演示模式...")
            logger.info("📝 演示模式将使用默认URL模拟完整的保存流程")
            game_url = None  # 使用默认URL
        else:
            # 默认情况下使用默认URL
            logger.info("📝 未指定URL，使用默认测试URL")
            game_url = None
        
        # 执行主要功能
        success = await save_game_to_baidu_pan(game_url)
        
        if success:
            logger.info("✅ 任务执行成功！")
            logger.info("📁 游戏已成功保存到百度网盘")
            if game_url:
                logger.info(f"🔗 处理的URL: {game_url}")
        else:
            logger.error("❌ 任务执行失败")
            if game_url:
                logger.error(f"🔗 失败链接URL: {game_url}")
            logger.error("💡 请检查网络连接、登录状态和页面结构")
        
        logger.info("=" * 60)
        logger.info("🏁 程序运行完成")
        
    except KeyboardInterrupt:
        logger.info("⏹️ 用户中断程序")
    except Exception as e:
        logger.error(f"💥 程序执行出错: {e}")
        raise


if __name__ == "__main__":
    asyncio.run(main())